# 定义一个常量数组，表示左，右，上，下四个方向
OFFSETS = [(-1, 0), (1, 0), (0, -1), (0, 1)]

# 深度优先搜索函数
def dfs(x, y, step, min_step_to_height, matrix, m, n, k, memo, visited):
    last_height = matrix[x][y] # 当前位置的高度
    
    # 遍历四个方向
    for offset in OFFSETS:
        new_x = x + offset[0]
        new_y = y + offset[1]
        
        # 超出范围
        if new_x < 0 or new_x >= m or new_y < 0 or new_y >= n:
            continue
        
        cur_height = matrix[new_x][new_y] # 新位置的高度
        
        # 高度差在 k 以内
        if abs(cur_height - last_height) <= k:
            step += 1 # 步数增加
            
            # 更新到达新高度的最短步数
            if cur_height not in min_step_to_height or min_step_to_height[cur_height] > step:
                min_step_to_height[cur_height] = step
            
            # 检查记忆化数组，避免重复计算
            if memo[new_x][new_y] == 0 or memo[new_x][new_y] > step:
                memo[new_x][new_y] = step
                visited[x][y] = True
                
                # 递归
                dfs(new_x, new_y, step, min_step_to_height, matrix, m, n, k, memo, visited)
                
                # 回溯时，将当前位置标记为未访问
                visited[x][y] = False
        
            step -= 1 # 回溯时，步数减少
            

def main():
    # 矩阵行和列 m, n，最大高度差 k
    m, n, k = map(int, input().split())
    # 初始化山地图矩阵
    matrix = [list(map(int, input().split())) for _ in range(m)]
    
    min_step_to_height = {matrix[0][0]:0} # 存储到达不同高度的最短步数
    memo = [[0] * n for _ in range(m)] # 记录已经访问过的位置和步数
    visited = [[False] * n for _ in range(m)] # 记录已经访问过的位置
    
    # 调用深度优先搜索函数
    dfs(0, 0, 0, min_step_to_height, matrix, m, n, k, memo, visited)
    
    # 计算最高峰的高度和最短步数
    max_height = max(min_step_to_height.keys())
    min_step = min_step_to_height[max_height]
    
    # 输出结果
    print(max_height, min_step)

if __name__ == "__main__":
    main()